home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / lang / Python16_Src.lha / Python16_Source / Modules / cgensupport.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-03  |  6.3 KB  |  354 lines
  1. /* Functions used by cgen output */
  2.  
  3. #include "Python.h"
  4. #include "cgensupport.h"
  5.  
  6.  
  7. /* Functions to extract arguments.
  8.    These needs to know the total number of arguments supplied,
  9.    since the argument list is a tuple only of there is more than
  10.    one argument. */
  11.  
  12. int
  13. PyArg_GetObject(args, nargs, i, p_arg)
  14.     register PyObject *args;
  15.     int nargs, i;
  16.     PyObject **p_arg;
  17. {
  18.     if (nargs != 1) {
  19.         if (args == NULL || !PyTuple_Check(args) ||
  20.                 nargs != PyTuple_Size(args) ||
  21.                 i < 0 || i >= nargs) {
  22.             return PyErr_BadArgument();
  23.         }
  24.         else {
  25.             args = PyTuple_GetItem(args, i);
  26.         }
  27.     }
  28.     if (args == NULL) {
  29.         return PyErr_BadArgument();
  30.     }
  31.     *p_arg = args;
  32.     return 1;
  33. }
  34.  
  35. int
  36. PyArg_GetLong(args, nargs, i, p_arg)
  37.     register PyObject *args;
  38.     int nargs, i;
  39.     long *p_arg;
  40. {
  41.     if (nargs != 1) {
  42.         if (args == NULL || !PyTuple_Check(args) ||
  43.                 nargs != PyTuple_Size(args) ||
  44.                 i < 0 || i >= nargs) {
  45.             return PyErr_BadArgument();
  46.         }
  47.         args = PyTuple_GetItem(args, i);
  48.     }
  49.     if (args == NULL || !PyInt_Check(args)) {
  50.         return PyErr_BadArgument();
  51.     }
  52.     *p_arg = PyInt_AsLong(args);
  53.     return 1;
  54. }
  55.  
  56. int
  57. PyArg_GetShort(args, nargs, i, p_arg)
  58.     register PyObject *args;
  59.     int nargs, i;
  60.     short *p_arg;
  61. {
  62.     long x;
  63.     if (!PyArg_GetLong(args, nargs, i, &x))
  64.         return 0;
  65.     *p_arg = (short) x;
  66.     return 1;
  67. }
  68.  
  69. static int
  70. extractdouble(v, p_arg)
  71.     register PyObject *v;
  72.     double *p_arg;
  73. {
  74.     if (v == NULL) {
  75.         /* Fall through to error return at end of function */
  76.     }
  77.     else if (PyFloat_Check(v)) {
  78.         *p_arg = PyFloat_AS_DOUBLE((PyFloatObject *)v);
  79.         return 1;
  80.     }
  81.     else if (PyInt_Check(v)) {
  82.         *p_arg = PyInt_AS_LONG((PyIntObject *)v);
  83.         return 1;
  84.     }
  85.     else if (PyLong_Check(v)) {
  86.         *p_arg = PyLong_AsDouble(v);
  87.         return 1;
  88.     }
  89.     return PyErr_BadArgument();
  90. }
  91.  
  92. static int
  93. extractfloat(v, p_arg)
  94.     register PyObject *v;
  95.     float *p_arg;
  96. {
  97.     if (v == NULL) {
  98.         /* Fall through to error return at end of function */
  99.     }
  100.     else if (PyFloat_Check(v)) {
  101.         *p_arg = (float) PyFloat_AS_DOUBLE((PyFloatObject *)v);
  102.         return 1;
  103.     }
  104.     else if (PyInt_Check(v)) {
  105.         *p_arg = (float) PyInt_AS_LONG((PyIntObject *)v);
  106.         return 1;
  107.     }
  108.     else if (PyLong_Check(v)) {
  109.         *p_arg = (float) PyLong_AsDouble(v);
  110.         return 1;
  111.     }
  112.     return PyErr_BadArgument();
  113. }
  114.  
  115. int
  116. PyArg_GetFloat(args, nargs, i, p_arg)
  117.     register PyObject *args;
  118.     int nargs, i;
  119.     float *p_arg;
  120. {
  121.     PyObject *v;
  122.     float x;
  123.     if (!PyArg_GetObject(args, nargs, i, &v))
  124.         return 0;
  125.     if (!extractfloat(v, &x))
  126.         return 0;
  127.     *p_arg = x;
  128.     return 1;
  129. }
  130.  
  131. int
  132. PyArg_GetString(args, nargs, i, p_arg)
  133.     PyObject *args;
  134.     int nargs, i;
  135.     string *p_arg;
  136. {
  137.     PyObject *v;
  138.     if (!PyArg_GetObject(args, nargs, i, &v))
  139.         return 0;
  140.     if (!PyString_Check(v)) {
  141.         return PyErr_BadArgument();
  142.     }
  143.     *p_arg = PyString_AsString(v);
  144.     return 1;
  145. }
  146.  
  147. int
  148. PyArg_GetChar(args, nargs, i, p_arg)
  149.     PyObject *args;
  150.     int nargs, i;
  151.     char *p_arg;
  152. {
  153.     string x;
  154.     if (!PyArg_GetString(args, nargs, i, &x))
  155.         return 0;
  156.     if (x[0] == '\0' || x[1] != '\0') {
  157.         /* Not exactly one char */
  158.         return PyErr_BadArgument();
  159.     }
  160.     *p_arg = x[0];
  161.     return 1;
  162. }
  163.  
  164. int
  165. PyArg_GetLongArraySize(args, nargs, i, p_arg)
  166.     PyObject *args;
  167.     int nargs, i;
  168.     long *p_arg;
  169. {
  170.     PyObject *v;
  171.     if (!PyArg_GetObject(args, nargs, i, &v))
  172.         return 0;
  173.     if (PyTuple_Check(v)) {
  174.         *p_arg = PyTuple_Size(v);
  175.         return 1;
  176.     }
  177.     if (PyList_Check(v)) {
  178.         *p_arg = PyList_Size(v);
  179.         return 1;
  180.     }
  181.     return PyErr_BadArgument();
  182. }
  183.  
  184. int
  185. PyArg_GetShortArraySize(args, nargs, i, p_arg)
  186.     PyObject *args;
  187.     int nargs, i;
  188.     short *p_arg;
  189. {
  190.     long x;
  191.     if (!PyArg_GetLongArraySize(args, nargs, i, &x))
  192.         return 0;
  193.     *p_arg = (short) x;
  194.     return 1;
  195. }
  196.  
  197. /* XXX The following four are too similar.  Should share more code. */
  198.  
  199. int
  200. PyArg_GetLongArray(args, nargs, i, n, p_arg)
  201.     PyObject *args;
  202.     int nargs, i;
  203.     int n;
  204.     long *p_arg; /* [n] */
  205. {
  206.     PyObject *v, *w;
  207.     if (!PyArg_GetObject(args, nargs, i, &v))
  208.         return 0;
  209.     if (PyTuple_Check(v)) {
  210.         if (PyTuple_Size(v) != n) {
  211.             return PyErr_BadArgument();
  212.         }
  213.         for (i = 0; i < n; i++) {
  214.             w = PyTuple_GetItem(v, i);
  215.             if (!PyInt_Check(w)) {
  216.                 return PyErr_BadArgument();
  217.             }
  218.             p_arg[i] = PyInt_AsLong(w);
  219.         }
  220.         return 1;
  221.     }
  222.     else if (PyList_Check(v)) {
  223.         if (PyList_Size(v) != n) {
  224.             return PyErr_BadArgument();
  225.         }
  226.         for (i = 0; i < n; i++) {
  227.             w = PyList_GetItem(v, i);
  228.             if (!PyInt_Check(w)) {
  229.                 return PyErr_BadArgument();
  230.             }
  231.             p_arg[i] = PyInt_AsLong(w);
  232.         }
  233.         return 1;
  234.     }
  235.     else {
  236.         return PyErr_BadArgument();
  237.     }
  238. }
  239.  
  240. int
  241. PyArg_GetShortArray(args, nargs, i, n, p_arg)
  242.     PyObject *args;
  243.     int nargs, i;
  244.     int n;
  245.     short *p_arg; /* [n] */
  246. {
  247.     PyObject *v, *w;
  248.     if (!PyArg_GetObject(args, nargs, i, &v))
  249.         return 0;
  250.     if (PyTuple_Check(v)) {
  251.         if (PyTuple_Size(v) != n) {
  252.             return PyErr_BadArgument();
  253.         }
  254.         for (i = 0; i < n; i++) {
  255.             w = PyTuple_GetItem(v, i);
  256.             if (!PyInt_Check(w)) {
  257.                 return PyErr_BadArgument();
  258.             }
  259.             p_arg[i] = (short) PyInt_AsLong(w);
  260.         }
  261.         return 1;
  262.     }
  263.     else if (PyList_Check(v)) {
  264.         if (PyList_Size(v) != n) {
  265.             return PyErr_BadArgument();
  266.         }
  267.         for (i = 0; i < n; i++) {
  268.             w = PyList_GetItem(v, i);
  269.             if (!PyInt_Check(w)) {
  270.                 return PyErr_BadArgument();
  271.             }
  272.             p_arg[i] = (short) PyInt_AsLong(w);
  273.         }
  274.         return 1;
  275.     }
  276.     else {
  277.         return PyErr_BadArgument();
  278.     }
  279. }
  280.  
  281. int
  282. PyArg_GetDoubleArray(args, nargs, i, n, p_arg)
  283.     PyObject *args;
  284.     int nargs, i;
  285.     int n;
  286.     double *p_arg; /* [n] */
  287. {
  288.     PyObject *v, *w;
  289.     if (!PyArg_GetObject(args, nargs, i, &v))
  290.         return 0;
  291.     if (PyTuple_Check(v)) {
  292.         if (PyTuple_Size(v) != n) {
  293.             return PyErr_BadArgument();
  294.         }
  295.         for (i = 0; i < n; i++) {
  296.             w = PyTuple_GetItem(v, i);
  297.             if (!extractdouble(w, &p_arg[i]))
  298.                 return 0;
  299.         }
  300.         return 1;
  301.     }
  302.     else if (PyList_Check(v)) {
  303.         if (PyList_Size(v) != n) {
  304.             return PyErr_BadArgument();
  305.         }
  306.         for (i = 0; i < n; i++) {
  307.             w = PyList_GetItem(v, i);
  308.             if (!extractdouble(w, &p_arg[i]))
  309.                 return 0;
  310.         }
  311.         return 1;
  312.     }
  313.     else {
  314.         return PyErr_BadArgument();
  315.     }
  316. }
  317.  
  318. int
  319. PyArg_GetFloatArray(args, nargs, i, n, p_arg)
  320.     PyObject *args;
  321.     int nargs, i;
  322.     int n;
  323.     float *p_arg; /* [n] */
  324. {
  325.     PyObject *v, *w;
  326.     if (!PyArg_GetObject(args, nargs, i, &v))
  327.         return 0;
  328.     if (PyTuple_Check(v)) {
  329.         if (PyTuple_Size(v) != n) {
  330.             return PyErr_BadArgument();
  331.         }
  332.         for (i = 0; i < n; i++) {
  333.             w = PyTuple_GetItem(v, i);
  334.             if (!extractfloat(w, &p_arg[i]))
  335.                 return 0;
  336.         }
  337.         return 1;
  338.     }
  339.     else if (PyList_Check(v)) {
  340.         if (PyList_Size(v) != n) {
  341.             return PyErr_BadArgument();
  342.         }
  343.         for (i = 0; i < n; i++) {
  344.             w = PyList_GetItem(v, i);
  345.             if (!extractfloat(w, &p_arg[i]))
  346.                 return 0;
  347.         }
  348.         return 1;
  349.     }
  350.     else {
  351.         return PyErr_BadArgument();
  352.     }
  353. }
  354.